/*
 * Copyright 2005-2013 finalist.cn. All rights reserved.
 * Support: http://www.finalist.cn
 * License: http://www.finalist.cn/license
 */
package com.finalist.util;

import java.io.IOException;
import java.io.Writer;
import java.util.List;
import java.util.Map;

import org.springframework.util.Assert;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.google.gson.Gson;
import com.google.gson.reflect.TypeToken;

/**
 * Utils - JSON
 * 
 * @author Finalist IT Group
 * @version 3.0
 */
public final class JsonUtils
{

    public final static Gson gson;

    static
    {
        gson = new Gson();
    }

    /** ObjectMapper */
    private static ObjectMapper mapper = new ObjectMapper();

    /**
     * 不可实例化
     */
    private JsonUtils()
    {
    }

    /**
     * 将对象转换为JSON字符串
     * 
     * @param value
     *            对象
     * @return JSOn字符串
     */
    public static String toJson(Object value)
    {
        try
        {
            return mapper.writeValueAsString(value);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 将JSON字符串转换为对象
     * 
     * @param json
     *            JSON字符串
     * @param valueType
     *            对象类型
     * @return 对象
     */
    public static <T> T toObject(String json, Class<T> valueType)
    {
        Assert.hasText(json);
        Assert.notNull(valueType);
        try
        {
            return mapper.readValue(json, valueType);
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }
        return null;
    }

    //	/**
    //	 * 将JSON字符串转换为对象
    //	 * 
    //	 * @param json
    //	 *            JSON字符串
    //	 * @param typeReference
    //	 *            对象类型
    //	 * @return 对象
    //	 */
    //	public static <T> T toObject(String json, TypeReference<?> typeReference) {
    //		Assert.hasText(json);
    //		Assert.notNull(typeReference);
    //		try {
    //			return mapper.readValue(json, typeReference);
    //		} catch (Exception e) {
    //			e.printStackTrace();
    //		}
    //		return null;
    //	}
    //
    //	/**
    //	 * 将JSON字符串转换为对象
    //	 * 
    //	 * @param json
    //	 *            JSON字符串
    //	 * @param javaType
    //	 *            对象类型
    //	 * @return 对象
    //	 */
    //	public static <T> T toObject(String json, JavaType javaType) {
    //		Assert.hasText(json);
    //		Assert.notNull(javaType);
    //		try {
    //			return mapper.readValue(json, javaType);
    //		} catch (Exception e) {
    //			e.printStackTrace();
    //		}
    //		return null;
    //	}

    /**
     * 将对象转换为JSON流
     * 
     * @param writer
     *            writer
     * @param value
     *            对象
     */
    public static void writeValue(Writer writer, Object value)
    {
        try
        {
            mapper.writeValue(writer, value);
        }
        catch (JsonGenerationException e)
        {
            e.printStackTrace();
        }
        catch (JsonMappingException e)
        {
            e.printStackTrace();
        }
        catch (IOException e)
        {
            e.printStackTrace();
        }
    }

    /**Gson方式将object转换成json
     * @param Object
     * @return String json
     */
    public static String toJsonByGson(Object obj)
    {
        return gson.toJson(obj);
    }

    /**将json转换成Object
     * @param json
     * @param Class<T>
     * @return T
     */
    public static <T> T toObj(String json, Class<T> clazz)
    {
        return gson.fromJson(json, clazz);
    }

    /** 
     * json转换字符串数组
     * @param json
     * @param String[]
     * @return java数组 
     */
    public static String[] json2StringArray(String json)
    {
        return gson.fromJson(json, new TypeToken<String[]>()
        {
        }.getType());
    }

    /**将json转换成List<String>
     * @param json
     * @return List<String>
     */
    public static List<String> json2List(String json)
    {
        return gson.fromJson(json, new TypeToken<List<String>>()
        {
        }.getType());
    }

    /**将json转换成Map<String, String>
     * @param json
     * @return Map<String, String>
     */
    public static Map<String, String> json2Map(String json)
    {
        return gson.fromJson(json, new TypeToken<Map<String, String>>()
        {
        }.getType());
    }

//    /**将json转换成指定泛型集合
//     * @param json
//     * @param typeToken<T>(Demo:new TypeToken<List<Map<String, String>>>(){})
//     * @return 泛型集合
//     */
//    public static <T> T json2Genericity(String json, TypeToken<T> typeToken)
//    {
//        return gson.fromJson(json, typeToken.getType());
//    }

}